
#encoding: latin-1
 
from Plateau import *
from Joueur import *
from QtPlateau import *
from Variables import *

import random

class Othello:
    """ Classe principale du jeu, qui stocke et gère les joueurs, le plateau de jeu, l'affichage graphique, et définit les principales méthodes de déroulement du jeu. """
    
    def __init__(self):
        """ Constructeur. """
        
        self.plateau = Plateau(PLATEAU_INITIAL[:])
        self.plateau.grille[44] = 0
        self.plateau.grille[45] = 0
        self.plateau.grille[54] = 0
        self.plateau.grille[55] = 0
        self.qtPlateau = QtPlateau(self)

    def Initialisation(self, mode):
        """ Initialisation d'une nouvelle partie, en s'adaptant au mode de jeu sélectionné. """
        
        self.partieTerminee = False
        self.mode = mode
        
        if mode == "jj":
        	self.joueur1 = Joueur(self, 'blanc')
        	self.joueur2 = Joueur(self, 'noir')
        elif mode == "jo":
        	self.joueur1 = Joueur(self, 'blanc')
        	self.joueur2 = Ordinateur(self, 'noir')
        elif mode == "oo":
        	self.joueur1 = Ordinateur(self, 'blanc')
        	self.joueur2 = Ordinateur(self, 'noir')
        	
        self.joueurMain = self.joueur1
        self.qtPlateau.updateMain()
        
        self.plateau = Plateau(PLATEAU_INITIAL[:])
        self.plateau.varCasesVides = CASES_VIDES_INITIAL[:]
        
        self.qtPlateau.updateScore()
        
    def partieOrdiVsOrdi(self):
        """ Gère les parties Ordi / Ordi, en les démarrant par quelques coups aléatoires permettant de ne pas toujours avoir le même résultat """
    
        # Début de partie : quelques coups aléatoires
        for i in range (6):
            # On choisit un coup aléatoirement
            coup = random.choice(self.plateau.coupsPossibles(self.joueurMain.joueur))
            # On joue le coup
            self.plateau.coup(coup, self.joueurMain.joueur)
            # On met à jour le plateau graphique et le score affiché
            self.qtPlateau.updateCases()
            self.qtPlateau.updateScore()
            # On change la main
            self.changeJoueurMain()
            
        # Suite et fin de partie : réflexion normale
        while not self.partieTerminee:
            self.joueurMain.reflexionJoueur()
            self.changeJoueurMain()
                

    def changeJoueurMain(self, n = 0):
        """ Change le joueur ayant la main, détecte la fin de la partie, et lance le coup de l'ordinateur si un joueur Humain vient de jouer (mode J/O). """
    
        # Détecte la fin de partie
        if n == 2:
            self.partieTerminee = True
            self.finJeu()
            return

        # Inverse les joueurs
        if self.joueurMain.joueur == 1:
        	self.joueurMain = self.joueur2
        else:
        	self.joueurMain = self.joueur1
        	
        # Met à jour l'affichage graphique du joueur ayant la main
        self.qtPlateau.updateMain()
            
        # Vérifie que le joueur ayant nouvellement la main peut jouer. Si ce n'est pas le cas, on change de nouveau le joueur ayant la main.
        if not self.plateau.peutJouer(self.joueurMain.joueur):
            return self.changeJoueurMain(n + 1)
            
        # Si le joueur ayant nouvellement la main est humain, la fonction s'arrête ici et on retourne dans la boucle des événements, en attente d'un clic sur le plateau.
        # En revanche, si le joueur ayant nouvellement la main est un ordinateur, et qu'on est dans le mode Joueur/Ordi, on démarre sa fonction "reflexionJoueur".
        if isinstance(self.joueurMain, Ordinateur) and self.mode == "jo":
            self.joueurMain.reflexionJoueur()
            self.changeJoueurMain()

    def finJeu(self):
        """ Fin du jeu """
        
        b, n = self.plateau.score()
        self.qtPlateau.afficheDialogFinPartie() 
     
# Lancement de l'application  
import sys
qApp = QtGui.QApplication(sys.argv)
Othello = Othello()
sys.exit(qApp.exec_())


